const fs = require("fs");
const path = require("path");
const { createCanvas, loadImage, registerFont } = require("canvas");
const { FFMPEG_PATH } = require("./ffmpeg");
const { loadConfig } = require("./config");

// 注册中文字体（如果存在）
const chineseFontPaths = ["C:/Windows/Fonts/msyh.ttc", "C:/Windows/Fonts/simsun.ttc", "C:/Windows/Fonts/simhei.ttf"];

let registeredFont = false;
for (const fontPath of chineseFontPaths) {
  if (fs.existsSync(fontPath)) {
    registerFont(fontPath, { family: "ChineseFont" });
    registeredFont = true;
    break;
  }
}

/**
 * 在首帧图片上添加标题文字
 * @param {string} firstFramePath - 首帧图片路径
 * @param {string} outputDir - 输出目录
 * @param {string} title - 标题文字
 * @returns {string|null} 添加文字后的图片路径或null（如果失败）
 */
async function addTextToFirstFrame(firstFramePath, outputDir, title) {
  // 确保output目录存在
  if (!fs.existsSync(outputDir)) {
    fs.mkdirSync(outputDir, { recursive: true });
  }

  const firstFrameWithTextPath = path.join(outputDir, "first-frame-with-text.jpg");

  try {
    // 加载首帧图片 - 使用文件缓冲区方式加载，避免路径问题
    console.log("  尝试加载首帧图片:", firstFramePath);
    const imageBuffer = fs.readFileSync(firstFramePath);
    const img = await loadImage(imageBuffer);
    console.log("  成功加载首帧图片");

    // 创建canvas
    const canvas = createCanvas(img.width, img.height);
    const ctx = canvas.getContext("2d");

    // 绘制原图
    ctx.drawImage(img, 0, 0);

    // 加载配置
    const config = loadConfig();
    const firstLineFontStyle = config.projectSettings?.firstLineFontStyle || {
      fontSize: 96,
      color: "white",
    };
    const secondLineFontStyle = config.projectSettings?.secondLineFontStyle || {
      fontSize: 72,
      color: "white",
    };

    // 获取字体族
    const defaultFontFamily = registeredFont ? "Microsoft YaHei" : "Arial";

    // 设置文本对齐方式
    ctx.textAlign = "center";
    ctx.textBaseline = "middle";

    const centerX = canvas.width / 2;
    const centerY = canvas.height / 2;
    console.log("  原始首帧图片尺寸:", img.width, "x", img.height);
    console.log("  文字位置:", centerX, centerY);

    if (title.includes("\n")) {
      // 处理多行文字
      const lines = title.split("\n");
      const baseLineHeight = Math.max(firstLineFontStyle.fontSize, secondLineFontStyle.fontSize);
      const lineHeight = baseLineHeight + 10;
      const totalHeight = lineHeight * lines.length;
      const startY = (canvas.height - totalHeight) / 2 + lineHeight / 2;

      lines.forEach((line, index) => {
        // 根据行号设置不同字体样式
        const fontStyle = index === 0 ? firstLineFontStyle : secondLineFontStyle;

        // 构建字体样式字符串
        const fontSize = fontStyle.fontSize || (index === 0 ? 96 : 72);
        const fontFamily = fontStyle.fontFamily || defaultFontFamily;
        const italic = fontStyle.fontStyle === "italic" ? "italic " : "";
        ctx.font = `${italic} ${fontSize}px ${fontFamily}`;
        ctx.fillStyle = fontStyle.color || "white";
        if (line.split(" ").length > 1) {
          const newLine = smartTextWrap(line, canvas, ctx);
          let newLineCnt = line.split("\n").length;

          const y = startY + index * lineHeight + (index === 0 ? 0 - fontSize * newLineCnt : newLineCnt * secondLineFontStyle.fontSize);
          ctx.fillText(centerAlignWithCanvas(newLine, canvas, ctx), centerX, y);
        } else {
          const y = startY + index * lineHeight;
          ctx.fillText(line, centerX, y);
        }
      });
    } else {
      // 绘制单行文字
      const fontSize = firstLineFontStyle.fontSize || 96;
      const fontFamily = firstLineFontStyle.fontFamily || defaultFontFamily;
      const italic = firstLineFontStyle.fontStyle === "italic" ? "italic " : "";
      ctx.font = `${italic}${fontSize}px ${fontFamily}`;
      ctx.fillStyle = firstLineFontStyle.color || "white";
      if (title.split(" ").length > 1) {
        const newLine = smartTextWrap(title, canvas, ctx);
        let newLineCnt = title.split("\n").length + 1;

        const y = startY + index * lineHeight + (index === 0 ? 0 - fontSize * newLineCnt : newLineCnt * fontSize);
        ctx.fillText(centerAlignWithCanvas(newLine, canvas, ctx), centerX, y);
      } else {
        ctx.fillText(title, centerX, centerY);
      }
    }

    // 保存图片
    const buffer = canvas.toBuffer("image/jpeg");
    fs.writeFileSync(firstFrameWithTextPath, buffer);
    console.log(`  首帧图片已添加文字: ${firstFrameWithTextPath}`);
    return firstFrameWithTextPath;
  } catch (error) {
    console.error("！！！处理首帧图片时出错:", error.message);
    console.error("！！！错误详情:", error);
    return null;
  }
}
function smartTextWrap(str, canvas, ctx) {
  // 计算宽度阈值（canvas宽度的80%）
  const widthThreshold = canvas.width * 0.95;

  // 检查字符串宽度是否超过阈值
  const textWidth = ctx.measureText(str).width;

  // 如果未超过阈值，直接返回原字符串
  if (textWidth <= widthThreshold) {
    return str;
  }

  // 从中间位置开始寻找空格
  let middle = Math.floor(str.length / 2);
  let splitIndex = -1;

  // 先向字符串末尾方向查找空格
  for (let i = middle; i < str.length; i++) {
    if (str[i] === " ") {
      splitIndex = i;
      break;
    }
  }

  // 如果未找到，再向字符串开始方向查找空格
  if (splitIndex === -1) {
    for (let i = middle; i >= 0; i--) {
      if (str[i] === " ") {
        splitIndex = i;
        break;
      }
    }
  }

  // 如果找不到空格，直接在中间位置分割
  if (splitIndex === -1) {
    splitIndex = middle;
  }

  // 分割字符串为两部分
  const part1 = str.substring(0, splitIndex);
  const part2 = str.substring(splitIndex + 1); // +1 是为了跳过空格

  // 递归处理两部分，然后用换行符连接
  const wrappedPart1 = smartTextWrap(part1, canvas, ctx);
  const wrappedPart2 = smartTextWrap(part2, canvas, ctx);

  return `${wrappedPart1}\n${wrappedPart2}`;
}

function centerAlignWithCanvas(str, canvas, ctx) {
  // 将字符串按换行符分割成数组
  const lines = str.split("\n");

  // 如果没有内容，直接返回
  if (lines.length === 0) return "";

  // 计算每一行的实际渲染宽度，找到最大宽度
  const lineWidths = lines.map(line => ctx.measureText(line).width);
  const maxWidth = Math.max(...lineWidths);

  // 对每一行进行居中处理
  const centeredLines = lines.map((line, index) => {
    // 当前行的宽度
    const currentWidth = lineWidths[index];
    // 计算需要添加的总空间宽度
    const totalSpaceWidth = maxWidth - currentWidth;

    // 如果当前行已是最宽，无需添加空格
    if (totalSpaceWidth <= 0) {
      return line;
    }

    // 计算左右两边需要的空格宽度
    const leftSpaceWidth = Math.ceil(totalSpaceWidth / 2);
    const rightSpaceWidth = Math.floor(totalSpaceWidth / 2);

    // 计算需要多少个空格才能达到所需宽度
    // 先测量单个空格的宽度
    const spaceWidth = ctx.measureText(" ").width;

    // 计算左右空格数量（处理spaceWidth为0的边缘情况）
    const leftSpaces = spaceWidth > 0 ? Math.ceil(leftSpaceWidth / spaceWidth) : 0;
    const rightSpaces = spaceWidth > 0 ? Math.ceil(rightSpaceWidth / spaceWidth) : 0;

    // 创建左右空格
    const leftPadding = " ".repeat(leftSpaces);
    const rightPadding = " ".repeat(rightSpaces);

    // 返回处理后的行
    return leftPadding + line + rightPadding;
  });

  // 将处理后的行重新组合成字符串
  return centeredLines.join("\n");
}

/**
 * 调整图片尺寸以适应视频尺寸
 * @param {string} imagePath - 原始图片路径
 * @param {string} outputPath - 输出图片路径
 * @param {number} videoWidth - 视频宽度
 * @param {number} videoHeight - 视频高度
 * @returns {boolean} 是否成功
 */
function resizeImage(imagePath, outputPath, videoWidth, videoHeight) {
  try {
    // 使用FFmpeg调整图片尺寸以适应视频尺寸，保持纵横比并居中
    const { execSync } = require("child_process");
    const resizeCommand = `"${FFMPEG_PATH}" -y -loglevel quiet -i "${imagePath}" -vf "scale=w=${videoWidth}:h=${videoHeight}:force_original_aspect_ratio=decrease,crop=w=min(${videoWidth}\\\\\\,iw):h=min(${videoHeight}\\\\\\,ih):x=(iw-min(${videoWidth}\\\\\\,iw))/2:y=(ih-min(${videoHeight}\\\\\\,ih))/2,pad=w=${videoWidth}:h=${videoHeight}:x=(ow-iw)/2:y=(oh-ih)/2:color=black" "${outputPath}"`;
    execSync(resizeCommand);
    return true;
  } catch (resizeError) {
    console.warn(`调整图片尺寸失败:`, resizeError.message);
    return false;
  }
}

/**
 * 过滤有效的媒体文件（图片或视频）
 * @param {Array} mediaFiles - 媒体文件路径数组
 * @returns {Array} 有效的媒体文件路径数组
 */
function filterValidImages(mediaFiles) {
  return mediaFiles.filter(mediaFile => {
    try {
      // 检查文件扩展名
      const ext = path.extname(mediaFile).toLowerCase();
      const validExtensions = [".jpg", ".jpeg", ".png", ".gif", ".mp4", ".mov", ".avi", ".mkv"];

      if (!validExtensions.includes(ext)) {
        return false;
      }

      const stats = fs.statSync(mediaFile);
      // 检查文件大小，过滤掉太小的文件（可能无效）
      return stats.size > 1024; // 大于1KB才认为是有效文件
    } catch {
      return false;
    }
  });
}

module.exports = {
  addTextToFirstFrame,
  resizeImage,
  filterValidImages,
  registeredFont,
};
